/**
 * @(#)IdManagerK.java Nov 10, 2006
 *
 * Copyright (c) 2005-2010 Psiqueware S.A. de C.V. All Rights Reserved.
 * This software is the proprietary information Psiqueware S.A. de C.V.
 * Use is subject to license terms.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * <br/>Usuario : AngelElectrico
 * <br/>Creaci&oacute;n: Nov 10, 2006 - 3:50:14 PM
 * <br/>
 * <br/>
 * <br/><t5>Cambios :</t5>
 * <br/><b>Fecha | Autor  |  Cambios</b>
 * <ul>
 * <li>Nov 10, 2006 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Angel El&eacute;ctrico</a> | Creaci&oacute;n del Objeto.</li>
 * <li>Ene 14, 2007 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Angel El&eacute;ctrico</a> | Se cambio la firma para activar un login, ya no incluye nada de correos, solo activa el login.</li>
 * <li>Ene 25, 2007 | <a href = "mailto:AngelElectrico@PsiqueWare.com">Angel El&eacute;ctrico</a> | Se resolvi&oacute; el problema de la transaccionalidad truca por las excepciones de par&aacute;metros..</li>
 * </ul>
 */

package com.psiqueware.alheli.id.manager;

import com.psiqueware.alheli.dao.DAOException;
import com.psiqueware.alheli.dao.EnlaceTransaccional;
import com.psiqueware.alheli.exception.NullArgumentException;
import com.psiqueware.alheli.exception.NullPostConditionException;
import com.psiqueware.alheli.id.*;
import com.psiqueware.alheli.id.dao.IdDAOFactory;
import com.psiqueware.alheli.id.dao.IdentificacionDAO;
import com.psiqueware.alheli.id.dao.UsuarioDAO;
import com.psiqueware.alheli.id.modelo.IdentificacionK;
import com.psiqueware.alheli.logging.Logger;
import com.psiqueware.alheli.logging.LoggerFactory;
import com.psiqueware.alheli.manager.BaseManager;
import com.psiqueware.alheli.manager.ManagerException;

import java.util.Date;
import java.util.List;

/**
 * Encargado de la informacion de autenticacion de un {@link Usuario}.
 * <br/>Paquete Original: com.psiqueware.basico.id.manager
 * <br/>Nombre  Original: AutenticadorTManagerK
 * <br/>Oprima para ver : <a href="IdManagerK.java.html"><i>C&oacute;digo Fuente</i> </a>
 *
 * @author <a href="mailto:AngelElectrico@PsiqueWare.com">Angel El&eacute;ctrico</a>
 * @version Revision: 1.1 Nov 10, 2006 3:50:14 PM
 * @noinspection DuplicateStringLiteralInspection, CastToConcreteClass, ClassWithoutToString, FeatureEnvy
 */
public final class IdManagerK extends BaseManager implements IdManager
{

    /**
     * Logger de clase para IdManagerK
     */
    private static final Logger s_log = LoggerFactory.getLogger(IdManagerK.class);

    /**
     * Constructor de IdManagerK.
     */
    public IdManagerK()
    {
    }


    /**
     * Genera una cadena semi-aleatoria util para realizar formas seguras.
     *
     * @return String semi-aleatoria de 16 caracteres de longitud.
     */
    public String generaCadenaAleatoria16Caracteres()
    {
        final StringBuilder sb = new StringBuilder(16);
        while (sb.length() < 17)
        {
            final long decimal = Long.parseLong(semillaAleatoria(new Date().getTime()));
            sb.append(Long.toHexString(decimal));
        }

        return sb.toString().substring(0, 16);
    }

    /**
     * Persistimos un nuevo {@link Identificacion}. Este nuevo Identificacion no se encuentra activado
     * es necesario activarlo para poder hacer uso de el.    Una excepci&oacute;n brotar&aacute; si el
     * {@link Usuario} ya ten&iacute;a un {@link Identificacion}; en ese caso utilizar  nuevaIdentificacion proporcionando
     * la contrase&ntilde;a anterior.
     *
     * @param usuario             {@link Usuario} a la que pertenece el {@link Identificacion}.
     * @param autenticacion       para autenticar a este {@link Usuario}.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return nuevo {@link Identificacion} persitido.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException en caso de no poder completar la operaci&oacute;n.
     */
    public Identificacion nuevaIdentificacion(final Usuario usuario, final char[] autenticacion, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        IdentificacionK oK = null;
        try
        {
            //Validamos
            if (null == autenticacion)
                throw new NullArgumentException("<error>El argumento password no puede ser NULL.</error>");
            if (null == usuario)
                throw new NullArgumentException("<error>El argumento 'usuario' no puede ser NULL.</error>");
            if (null == usuario.getId())
                throw new IllegalArgumentException("<error>El argumento 'usuario' deb&iacute;a encontrarse previamente persistido.</error>");

            //Creamos el objeto
            oK = new IdentificacionK(usuario, autenticacion);
            //guardamos el login.
            final IdentificacionDAO daoIdentificacion = IdDAOFactory.findDAOIdentificacion(enlaceTransaccional);
            daoIdentificacion.saveLogin(oK, enlaceTransaccional);
            //le agregamos la semilla de comprobaci&oacute;n.
            oK.setClaveActivacion(semillaAleatoria(oK.getId()));
            daoIdentificacion.updateLogin(oK, enlaceTransaccional);

        }
        catch (Exception e)
        {
            String error = "<error>No se pudo almacenar el Identificacion.</error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e, oK);
        }
        return oK;
    }


    /**
     * Cambia la informacion de autenticacion del {@link Identificacion}.
     * <p/>
     * Para el {@link Dominio} Asignado al {@link Usuario}.
     * <p/>
     * Esta operaci&oacute;n tambien puede ser utilizado en los casos en los que el {@link Identificacion} no haya
     * sido activado previamente y se desee hacerlo. En este caso la autentificacion anterior
     * puede ser igual a la nueva, el valor de activaci&oacute;n permanecer&aacute; desactivado.
     *
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     * @param usuario             cuyo {@link Identificacion} vamos a reemplazar.
     * @param authAnterior        para validar cambio.
     * @param authNueva           nuevo password.
     *
     * @return {@link Identificacion} con los cambios en caso de ser
     * valida la informacion; <code>null</code> en caso contrario.
     *
     * @throws ManagerException en caso de no poder completar la operaci&oacute;n.
     * @noinspection CastToConcreteClass
     */
    public Identificacion nuevaIdentificacion(final Usuario usuario, final char[] authAnterior, final char[] authNueva, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        Identificacion identificacionAnterior;
        try
        {
            //Validamos
            if (null == usuario)
                throw new NullArgumentException("<error>El argumento 'usuario' no puede ser NULL.</error>");
            if (null == usuario.getId())
                throw new IllegalArgumentException("<error>El argumento 'usuario' deb&iacute;a encontrarse previamente persistido.</error>");
            if (null == authAnterior)
                throw new NullArgumentException("<error>El argumento passwordAnterior no puede ser NULL.</error>");
            if (null == authNueva)
                throw new NullArgumentException("<error>El argumento passwordNuevo no puede ser NULL.</error>");

            //Validamos que exista un login anterior como se describe.
            final IdentificacionDAO daoIdentificacion = IdDAOFactory.findDAOIdentificacion(enlaceTransaccional);
            identificacionAnterior = daoIdentificacion.findLoginPorIdentificacion(usuario.getIdentificacion(), authAnterior, usuario.getIdDominio(), enlaceTransaccional);
            if (null == identificacionAnterior)
                throw new NullPostConditionException("<error>A fallado una postcondici&oacute;n. El argumento de salida 'identificacionAnterior' no puede ser NULL.</error>");

            //eliminamos el anterior
            daoIdentificacion.deleteLogin(identificacionAnterior, enlaceTransaccional);
            //creamos el nuevo
            final IdentificacionK login = (IdentificacionK) this.nuevaIdentificacion(usuario, authNueva, enlaceTransaccional);
            //le damos el mismo valor de activacion del Identificacion anterior
            login.setActivo(identificacionAnterior.getActivo());
            daoIdentificacion.updateLogin(login, enlaceTransaccional);
            return login;
        }
        catch (Exception e)
        {
            String error = "<error>No se pudo cambiar el password.</error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e);
        }
    }

    /**
     * Activa un login a partir de este. Marca como probado un correoElectronico y el login como activado.
     *
     * @param identificacion      A activar.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return <code>true</code> si se logro activar el login; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException en caso de no poder activar el login.
     * @noinspection CallToStringEquals
     */
    @Override
    public Boolean activarIdentificacion(final Identificacion identificacion, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        if (null == identificacion)
            throw new NullArgumentException("<error>El argumento 'identificacion' no puede ser NULL.</error>");
        if (null == identificacion.getId())
            throw new IllegalArgumentException("<error>El argumento 'identificacion' deb&iacute;a encontrarse previamente persistido.</error>");

        Boolean salida = Boolean.FALSE;
        try
        {
            final IdentificacionK iK = (IdentificacionK) identificacion;
            if (iK.activar(identificacion.getClaveActivacion()))
            {
                salida = Boolean.TRUE;
                IdDAOFactory.findDAOIdentificacion(enlaceTransaccional).updateLogin(iK, enlaceTransaccional);
            }
        }
        catch (Exception e)
        {
            String error = "<error>No se pudo activar el correoElectronico.</error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e);
        }
        return salida;
    }

    /**
     * Activa un login a partir de registrar su correoElectronico en el sistema. Marca como probado un correoElectronico y el login como activado.
     *
     * @param identificacion      nombre del usuario a activar.
     * @param claveActivacion     clave de activacion del correoElectronico del usuario.
     * @param autenticacion       para el usuario.
     * @param idDominio           id del {@link Dominio} al que pertenece la identificacion; <code>null</code> si no hay ninguno.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return <code>true</code> si se logro activar el login; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException en caso de no poder activar el login.
     * @noinspection CallToStringEquals
     */
    public Boolean activarIdentificacion(String identificacion, char[] autenticacion,final String claveActivacion, final Long idDominio, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        Boolean salida = Boolean.FALSE;
        try
        {
            IdentificacionK login = (IdentificacionK) IdDAOFactory.findDAOIdentificacion(enlaceTransaccional).findLoginPorIdentificacion(identificacion, autenticacion, idDominio, enlaceTransaccional);
            if (null != login)
            {
                if (login.activar(claveActivacion))
                {
                    salida = Boolean.TRUE;
                    IdDAOFactory.findDAOIdentificacion(enlaceTransaccional).updateLogin(login, enlaceTransaccional);
                }
            }
        }
        catch (Exception e)
        {
            String error = "<error>No se pudo activar el correoElectronico.</error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e);
        }
        return salida;
    }

    /**
     * Activa un login a partir de registrar su correoElectronico en el sistema.
     * Esto solo funciona para activar el primer login de un usuario.
     * Marca como probado un correoElectronico y el login como activado.
     *
     * @param identificacion      nombre del usuario a activar.
     * @param claveActivacion     clave de activacion del correoElectronico del usuario.
     * @param idDominio           id del {@link com.psiqueware.alheli.id.Dominio} al que pertenece la identificacion; <code>null</code> si no hay ninguno.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return <code>true</code> si se logro activar el login; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException en caso de no poder activar el login.
     * @noinspection CallToStringEquals
     */
    @Override
    public Boolean activarIdentificacion(final String identificacion, final String claveActivacion, final Long idDominio, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        Boolean salida = Boolean.FALSE;
        try
        {
            final IdentificacionDAO daoIdentificacion = IdDAOFactory.findDAOIdentificacion(enlaceTransaccional);
            IdentificacionK login = (IdentificacionK) daoIdentificacion.findLoginPorIdentificacion(identificacion, idDominio, enlaceTransaccional);
            if (null != login)
            {
                if (login.activar(claveActivacion))
                {
                    salida = Boolean.TRUE;
                    daoIdentificacion.updateLogin(login, enlaceTransaccional);
                }
            }
        }
        catch (Exception e)
        {
            String error = "<error>No se pudo activar el correoElectronico.</error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e);
        }
        return salida;
    }

    /**
     * Determina si un Usuario puede entrar al sistema.   Para el {@link Dominio} por defecto (<code>null</code>).
     *
     * @param identificacion      del {@link Identificacion} que se busca
     * @param autenticacion       del {@link Identificacion} que se busca
     * @param dominio             donde aplica el {@link Usuario}.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return {@link Identificacion} en caso de encontrarlo, <code>null</code> en caso de no poder entrar al sistema.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException si se presenta alg&uacute;n problema al acceder a persistencia.
     */
    public Identificacion identificar(final String identificacion, final char[] autenticacion, final Dominio dominio, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        Identificacion salida = null;
        try
        {
            if (null == identificacion)
                throw new NullArgumentException("<error>El argumento 'identificacion' no puede ser NULL.</error>");
            if (0 == identificacion.trim().length())
                throw new IllegalArgumentException("<error>El argumento 'identificacion' es una cadena vacia.</error>");
            if (null == autenticacion)
                throw new NullArgumentException("<error>El argumento 'autenticacion' no puede ser NULL.</error>");


            final UsuarioDAO usuarioDAO = IdDAOFactory.findDAOUsuario(enlaceTransaccional);
            final Usuario usuario = dominio == null ? usuarioDAO.findUsuarioPorIdentificacion(identificacion, enlaceTransaccional)
                                                    : usuarioDAO.findUsuarioPorIdentificacionDominio(identificacion, dominio, enlaceTransaccional);
            if (null != usuario)
            {
                final IdentificacionDAO daoIdentificacion = IdDAOFactory.findDAOIdentificacion(enlaceTransaccional);
                final IdentificacionK login = buscaLoginActivoUsuario(usuario, enlaceTransaccional);
                if (null != login
                    && login.getIdentificacion().equalsIgnoreCase(identificacion)
                    && daoIdentificacion.isAutenticacion(login, autenticacion, enlaceTransaccional))
                {
                    login.logear();
                    daoIdentificacion.updateLogin(login, enlaceTransaccional);
                    login.setUsuario(usuario);
                    salida = login;
                }
            }
        }
        catch (final Exception e)
        {
            String error = "<error>No se pudo realizar el logeo.</error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e, identificacion);
        }
        return salida;
    }

    /**
     * Identifica autom&aacute;ticamente al {@link Usuario} cuya identificaci&oacute;n es proporcionada.
     * Busca la informaci&oacute;n del {@link Identificacion} en persistencia y luego realiza un logeo
     * en el {@link Sesionable} de esta informaci&oacute;n.
     * <p/>
     * Para el {@link Dominio} por defecto (<code>null</code>).
     * <p/>
     * <b>&Uacute;sese con cautela. Esta operaci&oacute;n puede facilitar la entrada al sistema a un usuario sin las credenciales correctas.</b>
     *
     * @param identificacion      del {@link Usuario}.
     * @param sesionable          donde se realizar&aacute; el login.
     * @param dominio             donde aplica el {@link Usuario}.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return <code>true</code> si se pudo identificar el usuario; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException si no se puede realizar la acci&oacute;n.
     */
    public boolean identificar(final String identificacion, final Sesionable sesionable, final Dominio dominio, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        boolean salida = false;
        try
        {
            final Usuario usuario = IdDAOFactory.findDAOUsuario(enlaceTransaccional).findUsuarioPorIdentificacionDominio(identificacion, dominio, enlaceTransaccional);
            if (null != usuario)
            {
                IdentificacionK login = buscaLoginActivoUsuario(usuario, enlaceTransaccional);
                if (null != login)
                {
                    salida = sesionable.iniciarSession(identificacion, login.getAutentificacion());
                    if (salida)
                    {
                        login.logear();
                        IdDAOFactory.findDAOIdentificacion(enlaceTransaccional).updateLogin(login, enlaceTransaccional);
                    }
                }

            }
        }
        catch (final Exception e)
        {
            String error = "<error>No se pudo identificar en el sesionable.</error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e, identificacion);
        }
        return salida;
    }

    /**
     * Identifica al {@link Usuario} cuya identificaci&oacute;n es proporcionada.
     * <p/>
     * <p/>
     * Para el {@link Dominio} por defecto (<code>null</code>).
     * <p/>
     *
     * @param identificacion      con los datos de identificaci&oacute;n.
     * @param sesionable          donde se realizar&aacute; el identificacion.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return <code>true</code> si se pudo identificar el usuario; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException si no se puede realizar la acci&oacute;n.
     */
    public boolean identificar(final Identificacion identificacion, final Sesionable sesionable, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        return this.identificar(identificacion.getIdentificacion(), sesionable, enlaceTransaccional);
    }

    /**
     * Genera una cadena que permite el regenerar el {@link Identificacion} de un {@link Usuario}.
     *
     * @param usuario             cuyo {@link Identificacion} se pretende regenerar.
     * @param fechaExpiracion     fecha en la que se caducar&aacute; la cadena de regeneraci&oacute;n. Puede ser <code>null</code> si no se requiere que caduque la cadena.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return La cadena de regeneraci&oacute;n.
     *
     * @throws ManagerException si no se puede realizar la acci&oacute;n.
     */
    @Override
    public String generarCadenaRegeneracionIdentificacion(final Usuario usuario, final Date fechaExpiracion, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        try
        {
            final IdentificacionDAO daoIdentificacion = IdDAOFactory.findDAOIdentificacion(enlaceTransaccional);
            IdentificacionK activo = buscaLoginActivoUsuario(usuario, enlaceTransaccional);

            String cadenaRegeneracion = null;
            if (null != activo)
            {
                cadenaRegeneracion = generaCadenaAleatoria16Caracteres();
                activo.setExpiracionCambios(fechaExpiracion);
                activo.setClaveRegeneracion(cadenaRegeneracion);
                daoIdentificacion.updateLogin(activo, enlaceTransaccional);
            }
            return cadenaRegeneracion;
        }
        catch (final Exception e)
        {
            final String error = "<error><msg>No se pudo actualizar el Identificacion con la nueva clave de regeneraci&oacute;n.</msg><parametros>" + usuario.getIdentificacion() + "</parametros></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e, usuario);
        }
    }

    /**
     * Genera una cadena que permite activar la {@link Identificacion} de un {@link Usuario}. El {@link Usuario} tiene
     * que tener una {@link Identificacion} sin activar.
     *
     * @param usuario             cuyo {@link Identificacion} se pretende activar.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return La cadena de activaci&oacute;n; <code>null</code> si no se pudo generar una nueva cadena.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException si no se puede realizar la acci&oacute;n.
     */
    @Override
    public String regenerarClaveActivacionIdentificacion(final Usuario usuario, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        try
        {
            final IdentificacionDAO daoIdentificacion = IdDAOFactory.findDAOIdentificacion(enlaceTransaccional);
            final List<Identificacion> identificaciones = daoIdentificacion.findLoginsPorUsuario(usuario, enlaceTransaccional);
            String cadenaActivacion = null;
            if (identificaciones.size() == 1)
            {
                final IdentificacionK iK = (IdentificacionK) identificaciones.get(0);
                if (!iK.getActivo())
                {
                    cadenaActivacion = generaCadenaAleatoria16Caracteres();
                    iK.setClaveActivacion(cadenaActivacion);
                    daoIdentificacion.updateLogin(iK, enlaceTransaccional);
                }
            }
            return cadenaActivacion;
        }
        catch (final Exception e)
        {
            final String error = "<error><msg>No se pudo regenerar la cadena de activaci&oacute;n de la Identificacion.</msg><parametros>" + usuario.getIdentificacion() + "</parametros></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e, usuario);
        }
    }

    /**
     * Busca el {@link Identificacion} activo para el {@link Usuario}.
     *
     * @param usuario             cuyo {@link Identificacion} se busca.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return {@link Identificacion} en caso de encontrarlo; <code>null</code> en caso contrario.
     *
     * @throws DAOException si no se puede realizar la acci&oacute;n.
     */
    private IdentificacionK buscaLoginActivoUsuario(final Usuario usuario, final EnlaceTransaccional enlaceTransaccional) throws DAOException
    {
        final IdentificacionDAO daoIdentificacion = IdDAOFactory.findDAOIdentificacion(enlaceTransaccional);
        final List<Identificacion> identificacions = daoIdentificacion.findLoginsPorUsuario(usuario, enlaceTransaccional);
        IdentificacionK activo = null;
        for (final Identificacion identificacion : identificacions)
        {
            if (identificacion.getActivo())
            {
                activo = (IdentificacionK) identificacion;
                break;
            }
        }
        return activo;
    }

    /**
     * Regenera el {@link Identificacion} de un {@link Usuario} a partir de la cadena de regeneraci&oacute;n y su nueva autenticaci&oacute;n.
     * <p/>
     * El valor de activaci&oacute;n del nuevo {@link Identificacion} ser&aacute; el mismo que el del {@link Identificacion} anterior.
     *
     * @param usuario             cuyo {@link Identificacion} se pretende regenerar.
     * @param cadenaRegeneracion  cadena para realizar la regeneraci&oacute;n de la autentificacion.
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return el nuevo {@link Identificacion}, desactivado; <code>null</code> en caso de que el {@link Usuario} no tenga un {@link Identificacion} activo.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException si no se puede realizar la acci&oacute;n.
     */
    @Override
    public Identificacion regeneraIdentificacion(final Usuario usuario, final String cadenaRegeneracion, final char[] autentificacionNueva, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        try
        {
            if (null == cadenaRegeneracion)
                throw new NullArgumentException("<error>El argumento 'cadenaRegeneracion' no puede ser NULL.</error>");
            if (null == usuario)
                throw new NullArgumentException("<error>El argumento 'usuario' no puede ser NULL.</error>");
            if (null == usuario.getId())
                throw new IllegalArgumentException("<error>El argumento 'usuario' deb&iacute;a encontrarse previamente persistido.</error>");

            final IdentificacionK regenerar = buscaLoginActivoUsuario(usuario, enlaceTransaccional);
            if (null != regenerar && cadenaRegeneracion.equals(regenerar.getClaveRegeneracion()) &&
                (null == regenerar.getExpiracionCambios() || new Date().before(regenerar.getExpiracionCambios())))
            {
                //Desactivamos el login anterior.
                final Boolean activar = regenerar.getActivo();
                regenerar.setActivo(Boolean.FALSE);
                IdDAOFactory.findDAOIdentificacion(enlaceTransaccional).updateLogin(regenerar, enlaceTransaccional);
                //Creamos el nuevo Identificacion.
                final IdentificacionK nuevo = (IdentificacionK) nuevaIdentificacion(usuario, regenerar.getAutentificacion(), autentificacionNueva, enlaceTransaccional);
                //El nuevo Identificacion debera tener el mismo status que el anterior.
                nuevo.setActivo(activar);
                return nuevo;
            }
            else
            {
                return null;
            }
        }
        catch (final Exception e)
        {
            final String error = "<error><msg>No se pudo regenerar el Identificacion para el Usuario.</msg><parametros>" + usuario + "</parametros></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e);
        }
    }

    /**
     * Determina si un Usuario puede entrar al sistema.
     *
     * @param identificacion      del {@link Identificacion} que se busca
     * @param autenticacion       del {@link Identificacion} que se busca
     * @param enlaceTransaccional enlace para hacer at&oacute;micas las transacciones.
     *
     * @return {@link Identificacion} en caso de encontrarlo, <code>null</code> en caso de no poder entrar al sistema.
     *
     * @throws ManagerException si se presenta alg&uacute;n problema al acceder a persistencia.
     */
    public Identificacion identificar(final String identificacion, final char[] autenticacion, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        return identificar(identificacion, autenticacion, null, enlaceTransaccional);
    }

    /**
     * Identifica autom&aacute;ticamente al {@link Usuario} cuya identificaci&oacute;n es proporcionada.
     * Busca la informaci&oacute;n del {@link Identificacion} en persistencia y luego realiza un logeo
     * en el {@link Sesionable} de esta informaci&oacute;n.
     * <p/>
     * <p/>
     * <b>&Uacute;sese con cautela. Esta operaci&oacute;n puede facilitar la entrada al sistema a un usuario sin las credenciales correctas.</b>
     *
     * @param identificacion del {@link Usuario}.
     * @param sesionable     donde se realizar&aacute; el login.
     *
     * @return <code>true</code> si se pudo identificar el usuario; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException si no se puede realizar la acci&oacute;n.
     */
    public boolean identificar(final String identificacion, final Sesionable sesionable, final EnlaceTransaccional enlaceTransaccional) throws ManagerException
    {
        return this.identificar(identificacion, sesionable, null, enlaceTransaccional);
    }


    /**
     * Determina si un Usuario puede entrar al sistema o no.
     *
     * @param identificacion del {@link Identificacion} que se busca
     * @param autenticacion  del {@link Identificacion} que se busca
     *
     * @return {@link Identificacion} en caso de realizarse con &eacute;xito el Logeo, <code>null</code> en caso de no poder entrar al sistema.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException si se presenta alg&uacute;n problema al acceder a persistencia.
     */
    public boolean iniciarSession(final String identificacion, final char[] autenticacion) throws ManagerException
    {
        final EnlaceTransaccional enlaceTransaccional = nuevoEnlace();
        Identificacion login;
        try
        {
            enlaceTransaccional.iniciaTransaccion();
            login = this.identificar(identificacion, autenticacion, enlaceTransaccional);
        }
        catch (Exception e)
        {
            String error = "<error><msg>No se realizar el Identificacion</msg><parameter>" + identificacion + "</parameter></error>";
            s_log.error(error);
            s_log.error(e);
            enlaceTransaccional.rollBack();
            throw new ManagerException(error, e);
        }
        finally
        {
            enlaceTransaccional.finalizaTransaccion();
        }
        return login != null;
    }

    /**
     * Utilizado para invocar un cierre de session.
     *
     * @return <code>true</code> si se pudo cerrar la session; <code>false</code> en caso contrario.
     *
     * @throws com.psiqueware.alheli.manager.ManagerException si se presenta alg&uacute;n problema al acceder a persistencia.
     */
    public boolean finalizarSession() throws ManagerException
    {
        return true;
    }
}

